Best of Shareware/Best of PC Windows Shareware 1.0 - Wayzata Technology (7111) (1993).iso/mac/DOS/CAD_CAM/LASI42/LASIDRC.HLP

Text File | 1993-09-20 | 18KB | 428 lines

≡≡
Introduction

 Introduction

  The program LASIDRC.EXE is a design rule checking program that performs
  various layout design rule checks by making 2-dimensional bitmaps of
  drawing layers and then doing logical operations on the bitmaps. The
  program has some major changes and improvements over earlier versions of
  LASI design rule checkers:

  1. The program reads a Check File which contains parameters and operators
     that perform one or more checks. You can write your own Check File,
     and devise any type of design rule checks that you may want, within
     the limits of the available operations.

  2. The program now can find "near miss errors" where one area misses
     being to be connected to another area in a drawing by a single
     smallest drawing unit.

  3. The program can be interrupted at any check within the processing of a
     Check File, the state will be saved, and checking will continue in the
     area where it was suspended if LASILL is started again.

  The program works on a cell drawing in the default directory (drawing
  directory), and scans the cell in small areas, performing its sequence of
  operations. The results may be displayed on a monitor, may be stored in a
  disk file, or may be printed on a line printer. Automatic or manual
  hardcopies of the display may be made using the same hardcopy programs
  that LASI.EXE uses.

Running a Design Rule Check

 Running a Design Rule Check

  To run LASIDRC you first need to write a Check File as explained below.
  This file contains small "programs" that tell LASIDRC what to do.

  Log into the drawing directory and type "LASIDRC". LASIDRC will come up
  in a setup display, providing it finds the drawing files: FORM.DBD,
  CELLS4.DBD and CONSTS4.DBD. It will also allocate memory for LASI objects
  and its bitmaps. If any of this fails, it will tell you so and will
  return to DOS.

  1. When the Setup Display comes up, you can enter or change any
     parameters by moving around using the up, down, left, right or ENTER
     keys and then typing in any value. The values will be changed if any
     characters are typed and the location is then moved. You can step
     around and around until you have the parameters as you want them.

    The "Check File Name" is the name of the Check File that LASIDRC will
    use. It will always have the extension ".CHK", which will be added to
    the name.

    The "Name of Cell" is the main cell you want to check. Note that this
    also checks any lesser cells in the main cell.

    The "Check Start Number" is the test in the Check File where you want
    the checking to start. This allows you to skip over some tests.

    The "Check Finish Number is the last test you want to do. This allows
    some tests to be omitted.

    You may make a Summary File (always named LASIDRC.SUM). This is an
    appended file, which will keep information on all tests until it is
    erased.

    You may also print the summary information on a printer as the program
    runs. Alternately, you can just print the Summary File when it is done.

    There are two enables for the PAUSE and HCPY operators. You can turn
    these operators on and off as you please without editing the Check
    File.

    The resolution and distance may be overwritten if you want. These
    values stay in place until new RESOLUTION= or DISTANCE= parameters are
    encountered in the Check File in any of the following tests. Setting
    these parameters to "*" causes them to be ignored.

    You may start checking areas anywhere by writing the bottom-left
    coordinates in the setup. This allows you to go to an certain area in a
    cell without doing all the previous areas. Setting these parameters to
    "*" causes them to be ignored.

  The setup is slightly "smart"; it checks and adjusts parameters to
  conform to LASIDRC's checking rules. Units are automatically added to any
  dimensions. You will also notice that where "y" or "n" is wanted,
  anything but "y" will set "n".


  2. To start checking, press F10. Once you start checking, the parameters
     are saved in the LASIDRC.SET file and are returned when LASIDRC is run
     again. When LASIDRC runs a short status is displayed which moves up
     and down the screen as a screen saving feature.

    You may jump to the NEXT CHECK by pressing F10 again.

    You may abort checking by pressing ESC. You will go back to the Setup
    Display. When this is done, the last area position and the check number
    will be saved in the setup. If you start LASIDRC.EXE again this
    information will be restored.

    Press ESC to go from the Setup to DOS.

    Note:  There may be a short delay if ESC is pressed, be patient.

  3. Pressing F2 in Setup will read the contents of the Check File as it is
     seen by LASIDRC. That is, the defaults for parameters will be listed
     and any operators that have been disabled by making them into comments
     will not be shown.

  4. Pressing F3 in Setup will shell to DOS. You can run your favorite
     editor to make changes to the Check File, for example. Once in a while
     there will not be enough contiguous memory available to run a program;
     in that case you need to exit LASIDRC and go back to DOS. You may
     check the available memory by pressing F2.

  If a Check File is read completely, the program will terminate normally
  and go back to DOS. Certain setup parameters will be set to their default
  values.

The Check File

 Check File Format

  A Check File consists of one or more test sequences or checks arranged in
  blocks that contain parameters and operators. Each block starts with a
  TITLE parameter and is ended with an OPERATORS parameter. The OPERATORS
  parameter is always followed by a set of OPERATORS that are enclosed in
  brace characters "{" and "}".

  Characters may be upper or lowercase. The format is as follows:


  TITLE=aaaa<nl>            (40 char. max.)       []=optional
  [RESOLUTION=nnnn<nl>]     (in physical units)   <nl>=newline (CRLF)
  [DISTANCE=nnnn<nl>]       (in physical units)
  [LOCATION=xxxx,yyyy<nl>]  (in physical units)
  OPERATORS=<nl>
  {<nl>
    [OPERATOR<nl>]
    .
    .
    .
  }<nl>
  TITLE=bbbb<nl>
  etc.


  Check Parameters:

  TITLE= is the name of a particular test, and must be present. If no new
    title is read, the Check File is considered finished.

  RESOLUTION= is the physical size of each bit in a bitmap. This will be
    snapped to multiples of the basic units used in the drawing. Making
    this larger speeds up checking, but, details smaller than this number
    may be lost. This defaults to the previous setting if not present.

  DISTANCE= is the distance by which bitmaps will be expanded when spacing
    checks are being done. It also affect the position is the areas being
    checked. This defaults to the previous setting.

  LOCATION= sets the point on a cell of where to start scanning. This is
    the bottom-left corner of the area to be scanned. This does not default
    to any previous values.

  OPERATORS= begins the sequence of operator mnemonics that do the actual
    checking. The block of operators always starts with "{" and ends with
    "}". Each operator is written on a new line (CR-LF) and may contain
    arguments separated by a comma ",". Operators are read character by
    character starting after "=". The right brace "}" terminates the
    operations and the present check. There is space for a maximum of 50
    operators in the sequence.

  The variables above are recognized by only their first two characters and
  may be upper or lower case. For example, "op=" is equivalent to
  "OPERATORS=".

  A semicolon may be added to an operator line, which has the effect of
  making everything to the right a comment. You may "turn off" and operator
  by putting a ";" as the first character in the line. This lets you leave
  temporary operators in place in the file while you are working out a
  test.

 Working Maps

  The program maintains several internal 640x640 bitmaps. Only two are
  available to the user. These are the R (results) and S (secondary) maps.

  All tests are done by making and moving layer maps into the R and S
  working maps, where the various operators can work on them.

  R and S maps are arranged in a 2-map "stack" as shown below:


          PUSH layer map ────┐
                             
                           ┌─────────┐
                           │ │  R    │<─┐<── R Operator
            Map Stack      ├─│───────┤  │
                           │   S    │──┴─── RS Operator
                           └─────────┘


  To do any operations on maps you first push a layer map onto the map
  stack. When a map is pushed into R, the contents of R are first pushed
  into S.

  Certain operators work with the R map and some work with both the R and S
  maps. The results are always placed in the R map.

 Operators

  MAP,layer

    This creates a layer map file on the hard disk, which may be retrieved
    by other operators. Layer is a number from 0 to 64.

    Layer 0 is a special layer, will store the R map for later use at any
    stage of a checking sequence.

    You must ALWAYS use the MAP operator to generate a layer map if you are
    going to use that layer map later.


  PUSH,layer

    Retrieves a layer map from the hard disk and pushes the map onto the
    map stack. The contents of the R map are moved to the S map. The
    contents of the S map are lost. PUSH,0 retrieves and pushes a MAP,0
    that may have been previously stored.


  NOTR, ANDRS, ORRS, XORRS

    These are the logical operators that do just what they indicate. The
    results are placed in the R map and the S map remains unchanged.


  SETR,CLRR

    These are rarely used operators that set all bits of R to "1" or "0"
    respectively.


  DBLR

    This doubles the bits in X and Y directions so that single bits may be
    displayed better. This is used automatically by EXPR (below).


  EXPR[,offset]

    This is the single map expand operator. It performs an iterative
    octagonal (see below) expansion on the R map. Each iteration expands
    the pattern by ONE RESOLUTION UNIT. The results are placed in the R map
    and the original R map is lost.

    The results represent a pattern produced by single "0s" in the map as
    the "1s" merge with each expansion pass.

    The optional offset is a correction that may be used if found
    necessary. The offset is the number of iterations (or resolution units)
    to be subtracted from the expansion so that the distance parameter
    gives the correct results.


  EXPRS[,offset]

    This expands the R and S maps using an iterative octagonal expansion,
    and places the results in the R map. Each iteration is one resolution
    unit. The original R and S maps are lost. Since there are two separate
    maps, the result is the intersection of the maps as they expand.


  TESTR

    This is a conditional branching operator that tests if any bits are set
    to "1" in the R map. If there are any "1s" the sequence of operators
    continues. If there are no results, the rest of the operators are
    skipped and the sequence of operators starts over again in the next
    drawing area. This is used to determine is there is anything to print
    or display.


  DSPR,color index,sparse modulus

    This displays the R map as a rectangular pattern on the monitor screen.
    The color index is the usual integerr (0 to 15) used by the PC video to
    set a color: 0=black, 1= blue, 2=green, etc.

    The sparse modulus is a integer that allows only those pixels whose X
    and Y position divided by the modulus that leaves a remainder of 0 to
    be displayed. This "thins out" the filled patterns to give a better
    display or print. For all pixels, the modulus is 1; for every other
    pixel, the modulus is 2, etc.


  DSP,map,color index,sparse modulus

    This is the same as DSPR except it displays a stored map. Use this to
    display the layers as a background when displaying any results.


  PAUSE

    This produces a pause after a display so that you can examine the
    screen. Without it, LASIDRC would go on to the next area to be checked.
    This is enabled by the Setup switch.


  HCPY

    This calls the hardcopier automatically to produce a picture of the
    screen after any results are displayed. If the Print Summary Setup
    switch is set this does not work, since it would disrupt the summary
    printing. This must also be enabled by the Setup switch.

Octagonal Expansion

 Octagonal Expansion

  When an expansion is done, an iterative process is used to enlarge the
  map patterns. With each pass the pattern is enlarged by one bit by
  shifting it in each of the four orthogonal directions (+x,-x,+y,-y). It
  is also shifted diagonally, on the average, .707 of the time. This
  produces an octagonal pattern if the original pattern is a single point.


                                            * * * * *
    Octagonal single point expansion      * * * * * * *
    after four passes                   * * * * * * * * *
                                        * * * * * * * * *
                                        * * * * X * * * *
                                        * * * * * * * * *
                                        * * * * * * * * *
                                          * * * * * * *
                                            * * * * *

Optimizing Parameters

 Optimizing Parameters

  Resolution can be made as small as 1 basic unit used in a drawing.

  Making the Resolution larger allows checking to be done much faster
  because larger pieces of a drawing can be checked at a time and less
  iterations are necessary when checking. The time required to check is
  roughly in inverse proportion to the 3rd power of the Resolution. That
  is, if you halve your Resolution it will run about 8 times faster. Unless
  you have a very fast computer, the highest Resolution is best used on
  small cells or for checks that involve small dimensions. For example,
  contact coverage or checking for small gaps in metal runs might run at
  the smallest Resolution.

  Making Resolution too large can cause errors to be missed because details
  cannot be resolved smaller than that size and roundoffs may occur.
  However, scanning for gross errors can quickly be done using a larger
  Resolution.

  The Distance parameter will affect the test time, since each iteration of
  an expansion takes about the same amount of time.

  Distance will also affect the size and position of the areas being
  checked. Distance can be set to 0, but a small correction, depending on
  the Resolution, will be made so that checked areas will overlap slightly.

Missed and False Errors

 Missed and False Errors

  When checking distances, if programmed correctly, LASIDRC should always
  find an flag distances <= (Distance - Resolution). For example, a 10 um
  Distance and a Resolution of .5um should find anything less than or equal
  to 9.5um. Note that as the Resolution approaches zero, this distance
  approaches the Distance.

  This does not mean that all distances will be accepted if they are
  greater than (Distance - Resolution). For 45 deg. diagonal distances,
  there can be an uncertainty that is less than +/- half the Resolution,
  due partly to the way that LASIDRC works and due partly to numerical
  roundoff problems. For angles that are in a range centered around odd
  multiples of 22.5 deg. ( 22.5, 67.5, etc.) there is an exaggeration of
  the expansion distance. This may flag oddly shaped objects. Since LASIDRC
  expands areas using an octogonal pattern, these exaggerations correspond
  to the octogon vertex peaks or about an 8 percent exaggeration at most.

  Since LASIDRC looks for single bits when doing a single layer expansion,
  once in a while on odd shapes, the map can produce single bit extensions
  or notches. LASIDRC will find these and will flag them, even though they
  are an artifact. You should examine these and see if there really is
  anything wrong. In fact, the way that LASIDRC works often picks out
  patterns that are not good layout practice.

  LASIDRC works in such a way that sharp corners tend to be rounded, just
  as actual photomasking and etching might do. Keep this in mind when
  setting the Distance parameter. For example, the distance between two
  adjacent corners will be seen by LASIDRC as a little more than the actual
  tip to tip distance.

  The method by which LASIDRC works is sensitive to gross errors which are
  well beyond the actual flagging threshold. It is virtually impossible for
  LASIDRC to miss these.

  LASIDRC will find "near miss" errors in which there is a gap between
  filled areas that is greater than or equal to the value set as the
  Resolution. Set the Resolution to the smallest physical unit (1 basic
  drawing unit), and set the Distance to some value large enough to find
  all small gaps, but small enough to let LASIDRC run quickly. On strange
  shapes, LASIDRC will sometimes flag small notches. Ignore these if they
  cause no trouble.

Disclaimer

 Disclaimer

  The LASIDRC.EXE program is furnished on an "as is" basis. LASIDRC will
  make a "best effort" to call to attention any possible layout errors.
  Experience should confirm that it doesn't miss much. However, the author
  or anyone distributing the program cannot assume responsibility for how
  the program is used, how it is programmed or for the results of its use.
  The program cannot be absolutely guaranteed to find all instances in a
  layout that may result in incorrect function of an integrated circuit or
  other device. LASIDRC is to be considered as a valuable aid to actual
  visual inspection and the users own knowledge.